src/services/session_management.py (1)

54-62: Implement proper user authentication

The authenticate_player method currently uses placeholder logic with hardcoded credentials. This is insecure and should be replaced with a proper authentication mechanism, such as verifying credentials against a user database.

Would you like assistance in implementing secure user authentication? I can help integrate authentication against a user database or service.

main.py (1)

96-97: Include exception details in the error logging

The variable e is assigned but not used. Including exception details in the log can aid in debugging without exposing sensitive information to the user.

Apply this diff to log the exception:

 except Exception as e:
-    MessageView.show_error("An unexpected error occurred during character creation")
+    MessageView.show_error("An unexpected error occurred during character creation")
+    logger.error(f"Unexpected error during character creation: {str(e)}", exc_info=True)
     return

This way, the exception details are logged for debugging purposes while keeping error messages user-friendly.

🧰 Tools

🪛 Ruff (0.8.2)

96-96: Local variable e is assigned to but never used

Remove assignment to unused variable e

(F841)

src/services/shop.py (2)

324-345: Add Error Handling for Database Operations in 'save_shop_state'

The save_shop_state method lacks error handling for database operations. If an exception occurs during the database transaction, it may crash the application. Consider adding try-except blocks to handle exceptions gracefully.

Apply this diff to add error handling:

 def save_shop_state(self, player_id: str) -> None:
     """Save the current shop state to the database"""
     shop_state = {
         "shop_type": self.shop_type.value,
         "current_event": self.current_event.name if self.current_event else None,
         "inventory": [
             {"item": item.item.serialize(), "quantity": item.quantity}
             for item in self.inventory
         ],
     }
     shop_state_json = json.dumps(shop_state)
+    try:
         self.cursor.execute(
             """
             INSERT INTO shop_states (player_id, shop_state)
             VALUES (%s, %s)
             ON CONFLICT (player_id) DO UPDATE
             SET shop_state = EXCLUDED.shop_state
             """,
             (player_id, shop_state_json),
         )
         self.connection.commit()
+    except psycopg2.Error as e:
+        self.connection.rollback()
+        MessageView.show_error(f"Failed to save shop state: {str(e)}")

🧰 Tools

🪛 Ruff (0.8.2)

335-335: Undefined name json

(F821)

---

347-373: Add Error Handling for Database Operations in 'load_shop_state'

Similar to save_shop_state, the load_shop_state method should handle potential exceptions during database operations to prevent application crashes and provide informative error messages.

Apply this diff to add error handling:

 def load_shop_state(self, player_id: str) -> None:
     """Load the shop state from the database"""
+    try:
         self.cursor.execute(
             """
             SELECT shop_state FROM shop_states
             WHERE player_id = %s
             """,
             (player_id,),
         )
         result = self.cursor.fetchone()
         if result:
             shop_state_json = result[0]
             shop_state = json.loads(shop_state_json)
             self.shop_type = ShopType(shop_state["shop_type"])
             self.current_event = (
                 ShopEvent(shop_state["current_event"], 1.0)
                 if shop_state["current_event"]
                 else None
             )
             self.inventory = [
                 ShopItem(
                     item=Item.deserialize(item_data["item"]),
                     quantity=item_data["quantity"],
                 )
                 for item_data in shop_state["inventory"]
             ]
+    except psycopg2.Error as e:
+        MessageView.show_error(f"Failed to load shop state: {str(e)}")

🧰 Tools

🪛 Ruff (0.8.2)

359-359: Undefined name json

(F821)

src/services/character_creation.py (1)

150-156: Add Error Handling for Authentication Failures

The authenticate_player method does not handle cases where authentication might fail (e.g., incorrect credentials or connection issues). Consider adding error handling to manage exceptions and provide user feedback.

Apply this diff to add error handling:

 @staticmethod
 def authenticate_player() -> Optional[Player]:
     """Authenticate player during character creation"""
     session_service = SessionManagementService()
     session_service.show_login_screen()
-    player = session_service.authenticate_player()
+    try:
+        player = session_service.authenticate_player()
+    except AuthenticationError as e:
+        MessageView.show_error(f"Authentication failed: {str(e)}")
+        return None
     return player

Ensure that AuthenticationError is the appropriate exception and that it's imported if necessary.

README.md (1)

56-61: Enhance multiplayer documentation with implementation details

While the section provides a good overview, consider adding more specific details about:

• Maximum number of players supported per game
• How the turn-based queue system works (order, timeouts, etc.)
• Network requirements (bandwidth, latency considerations)
• Authentication methods and session management details

src/display/combat/combat_view.py (3)

18-18: Add docstring to clarify the method's new multiplayer behavior

The method signature has been updated but the docstring doesn't reflect the multiplayer changes.

-    def show_combat_status(players: List[Player], enemies: List[Enemy], combat_log: List[str]):
-        """Display combat status with improved visual flow"""
+    def show_combat_status(players: List[Player], enemies: List[Enemy], combat_log: List[str]):
+        """Display combat status for multiplayer battles.
+        
+        Args:
+            players: List of Player instances in the battle
+            enemies: List of Enemy instances in the battle
+            combat_log: List of recent combat messages
+        """

---

24-43: Improve enemy display for multiplayer battles

The enemy display section could be enhanced to better support multiple enemies.

         print(f"\n{dec['SECTION']['START']}Enemies{dec['SECTION']['END']}")
         for enemy in enemies:
-            print(f"  {sym['SKULL']} {enemy.name}\n")
+            # Add enemy index for targeting
+            enemy_index = enemies.index(enemy) + 1
+            print(f"  {sym['SKULL']} [{enemy_index}] {enemy.name}\n")

             # Show enemy art if available
             if hasattr(enemy, "art") and enemy.art:
                 print(enemy.art)
             else:
                 # Display default art or placeholder
                 print("     ╔════════╗")
                 print("     ║  (??)  ║")
                 print("     ║  (||)  ║")
                 print("     ╚════════╝")

             # Enemy health bar
             health_percent = enemy.health / enemy.max_health
             health_bar = "█" * int(health_percent * 20)
             health_bar = health_bar.ljust(20, "░")
             print(f"\n  {sym['HEALTH']} Health: {enemy.health}/{enemy.max_health}")
             print(f"  [{health_bar}]")
+            
+            # Enemy status effects
+            if enemy.status_effects:
+                print(f"  {sym['EFFECT']} Effects:", end=" ")
+                print(", ".join(effect.name for effect in enemy.status_effects))

---

Line range hint 93-183: Update remaining methods for multiplayer support

Several methods still use single player/enemy parameters and need to be updated for multiplayer:

1. show_battle_result: Should handle multiple players and enemies
2. show_level_up: Should support multiple players leveling up simultaneously
3. show_retreat_attempt: Should handle group retreat scenarios

Example update for show_battle_result:

     @staticmethod
-    def show_battle_result(player: Player, enemy: Enemy, rewards: dict):
+    def show_battle_result(players: List[Player], enemies: List[Enemy], rewards: Dict[str, Dict]):
         """Display battle results with a simple dark RPG theme"""
         print(f"\n{dec['TITLE']['PREFIX']}Battle Results{dec['TITLE']['SUFFIX']}")
         print(f"{dec['SEPARATOR']}")
 
-        print("\n  The enemy is defeated.")
-        print(f"  {sym['SKULL']} {enemy.name} has fallen.")
+        print("\n  The enemies are defeated.")
+        for enemy in enemies:
+            print(f"  {sym['SKULL']} {enemy.name} has fallen.")
 
-        print(f"\n{dec['SECTION']['START']}Rewards{dec['SECTION']['END']}")
-        print(f"  {sym['EXP']} Experience: +{rewards.get('exp', 0)}")
-        print(f"  {sym['GOLD']} Gold: +{rewards.get('gold', 0)}")
+        for player in players:
+            player_rewards = rewards.get(player.name, {})
+            print(f"\n{dec['SECTION']['START']}Rewards for {player.name}{dec['SECTION']['END']}")
+            print(f"  {sym['EXP']} Experience: +{player_rewards.get('exp', 0)}")
+            print(f"  {sym['GOLD']} Gold: +{player_rewards.get('gold', 0)}")

Configuration used: CodeRabbit UI
Review profile: CHILL

Configuration used: CodeRabbit UI
Review profile: CHILL

-                boss_result = boss_service.handle_boss_turn(enemy, random.choice(player_queue))
-                combat_log.insert(
-                    0,
-                    f"{sym['SKILL']} {enemy.name} uses {boss_result.skill_used} for {boss_result.damage} damage!",
-                )
-                target = random.choice(player_queue)
-                target.health -= boss_result.damage
+                target = random.choice(player_queue)
+                boss_result = boss_service.handle_boss_turn(enemy, target)
+                combat_log.insert(
+                    0,
+                    f"{sym['SKILL']} {enemy.name} uses {boss_result.skill_used} on {target.name} for {boss_result.damage} damage!",
+                )
+                target.health -= boss_result.damage

-                escape_chance = 0.7 - (sum(enemy.level for enemy in enemy_queue) / len(enemy_queue) * 0.05)
+                escape_chance = max(0.1, 0.7 - (sum(enemy.level for enemy in enemy_queue) / len(enemy_queue) * 0.05))

src/services/combat.py (3)

85-89: Enhance function documentation

The function documentation should be expanded to include:

• Parameter descriptions
• Return value explanation
• Possible return values (None, True, False) and their meanings

 def combat(
     players: List[Player], enemies: List[Enemy], combat_view: CombatView, shop: Shop
 ) -> Optional[bool]:
-    """Handle turn-based combat sequence for multiple players and enemies."""
+    """Handle turn-based combat sequence for multiple players and enemies.
+    
+    Args:
+        players: List of Player objects participating in combat
+        enemies: List of Enemy objects to fight against
+        combat_view: CombatView instance for displaying combat information
+        shop: Shop instance for handling post-combat rewards
+    
+    Returns:
+        Optional[bool]: 
+        - True for victory (all enemies defeated)
+        - False for successful retreat
+        - None for defeat (all players defeated)
+    """

---

221-223: Enhance player defeat feedback

When a player is defeated and removed from the queue, there should be clear visual feedback to improve user experience.

 if player.health <= 0:
+    combat_log.insert(0, f"{sym['DEFEAT']} {player.name} has been defeated!")
+    time.sleep(DISPLAY_SETTINGS.get("DEFEAT_DELAY", 1))
     player_queue.remove(player)

---

263-267: Consider additional end-of-turn mechanics

The end-of-turn logic could be enhanced with:

• Status effect processing using the existing process_status_effects function
• Basic resource regeneration (e.g., small mana regeneration)

 # Update skill cooldowns at end of turn
 for player in player_queue:
     for skill in player.skills:
         skill.update_cooldown()
+    # Process status effects
+    process_status_effects(player)
+    # Basic mana regeneration
+    player.mana = min(player.max_mana, player.mana + GAME_BALANCE.get("MANA_REGEN_PER_TURN", 1))

terraform/server/main.tf (2)

37-45: Mark sensitive outputs and add additional metadata

Consider marking the public IP as sensitive and add more descriptive outputs for better operational visibility.

Enhance the outputs:

 output "instance_id" {
   description = "The ID of the EC2 instance"
   value       = module.ec2_instance.id
 }

 output "public_ip" {
   description = "The public IP address of the EC2 instance"
   value       = module.ec2_instance.public_ip
+  sensitive   = true
 }
+
+output "instance_arn" {
+  description = "The ARN of the EC2 instance"
+  value       = module.ec2_instance.arn
+}
+
+output "instance_state" {
+  description = "The current state of the EC2 instance"
+  value       = module.ec2_instance.instance_state
+}

---

1-45: Consider adding essential operational components

The current configuration lacks several important operational and security features.

Consider adding:

1. Enable EBS encryption for the root volume
2. Configure CloudWatch monitoring and logging
3. Set up backup strategies using AWS Backup
4. Implement proper networking with private subnets and NAT Gateway
5. Add tags for cost allocation and resource management

Example implementation structure:

# Enable detailed monitoring
module "ec2_instance" {
  # ...
  monitoring = true
  root_block_device {
    encrypted = true
  }
  # ...
}

# Add CloudWatch Log Group
resource "aws_cloudwatch_log_group" "game_server" {
  name              = "/terminal-quest/game-server"
  retention_in_days = 30
  tags = {
    Environment = var.environment
    Application = "terminal-quest"
  }
}

# AWS Backup configuration
resource "aws_backup_plan" "game_server" {
  name = "terminal-quest-backup-plan"
  # Add backup rules
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

.github/workflows/build-and-test.yml (1)

13-14: Consider testing against multiple Python versions

Currently only testing against Python 3.12. Consider adding Python 3.11 for broader compatibility, as some AWS Lambda environments might still use it.

 matrix:
   python-version: [
-    "3.12"
+    "3.11",
+    "3.12"
   ]

migrations/env.py (1)

21-21: Set target_metadata to enable Alembic autogeneration

Currently, target_metadata is set to None. To utilize Alembic's autogenerate feature for automatic migration script generation, set target_metadata to your models' metadata.

You can update it as follows:

-target_metadata = None
+from your_model_module import Base  # Replace with your actual models module
+target_metadata = Base.metadata

src/models/boss.py (1)

2-2: Remove unused import Dict

Line 2 imports Dict from the typing module, but Dict is not used anywhere in the code. Removing unused imports helps keep the code clean and avoid unnecessary dependencies.

Apply this diff to remove the unused import:

-from typing import List, Optional, Dict
+from typing import List, Optional

🧰 Tools

🪛 Ruff (0.8.2)

2-2: typing.Dict imported but unused

Remove unused import: typing.Dict

(F401)

src/models/boss_types.py (1)

2-2: Remove unused imports VoidShieldEffect and HopesCorruptionEffect

Line 2 imports VoidShieldEffect and HopesCorruptionEffect from .effects.item_effects, but these imports are not used in this file. Removing unused imports helps maintain code clarity and efficiency.

Apply this diff to remove the unused imports:

-from .effects.item_effects import VoidShieldEffect, HopesCorruptionEffect
+from .effects.item_effects import (
+    StatModifierEffect,
+    OnHitEffect,
+)

🧰 Tools

🪛 Ruff (0.8.2)

2-2: .effects.item_effects.VoidShieldEffect imported but unused

Remove unused import

(F401)

---

2-2: .effects.item_effects.HopesCorruptionEffect imported but unused

Remove unused import

(F401)

src/models/character_classes.py (2)

11-11: Initialize optional attribute art with field(default=None)

Line 15 declares art with a default value of None. While this works, it's more explicit and idiomatic to use field(default=None) for default values in data classes, especially if future modifications are made.

Apply this diff to make the change:

 art: str = None
+art: str = field(default=None)

---

41-116: Encourage reusability by defining skills outside of character definitions

In lines 41-116, skills are directly defined within the character class instances. To improve code reusability and maintainability, consider defining the skills separately and referencing them in the character classes. This approach avoids duplication if the same skills are used by multiple classes and makes it easier to manage skill definitions.

Example of how to define skills separately:

# Define skills outside
spectral_strike = Skill(
    name="Spectral Strike",
    damage=25,
    mana_cost=20,
    description="Unleashes a ghostly attack that pierces through defenses",
    cooldown=1,
)

# Reference in the character class
CharacterClass(
    ...,
    skills=[spectral_strike, soul_drain],
)

src/models/items/legendary_items.py (1)

2-8: Organize imports for clarity and maintainability

The imports from item_effects in lines 2-8 can be organized for better readability. Group related effects together and consider importing only what is necessary.

Apply this diff to organize the imports:

 from .base import ItemType, ItemRarity
 from ..effects.item_effects import (
     ShadowLifestealEffect,
     VoidShieldEffect,
     HopesCorruptionEffect,
     StatModifierEffect,
     OnHitEffect,
 )

src/display/main/main_view.py (2)

1-1: Remove unused imports Dict and List

The Dict and List imports from the typing module are not used and can be safely removed to clean up the code.

Apply this diff to remove the unused imports:

-from typing import Dict, List

🧰 Tools

🪛 Ruff (0.8.2)

1-1: typing.Dict imported but unused

Remove unused import

(F401)

---

1-1: typing.List imported but unused

Remove unused import

(F401)

---

100-100: Rename unused loop variable i to _

The loop control variable i is not used within the loop body. Renaming it to _ indicates that it is intentionally unused and adheres to best practices.

Apply this diff to rename i to _:

-for i, item in enumerate(player.inventory["items"], 1):
+for _, item in enumerate(player.inventory["items"], 1):

🧰 Tools

🪛 Ruff (0.8.2)

100-100: Loop control variable i not used within loop body

Rename unused i to _i

(B007)

src/models/effects/item_effects.py (1)

1-1: Remove unused import List from typing

The List type is imported but not used in the file. Removing unused imports helps keep the code clean.

Apply this diff to remove the unused import:

- from typing import Dict, Optional, List, TYPE_CHECKING
+ from typing import Dict, Optional, TYPE_CHECKING

🧰 Tools

🪛 Ruff (0.8.2)

1-1: typing.List imported but unused

Remove unused import: typing.List

(F401)

main.py (2)

17-18: Remove unused imports to clean up code

The imports STARTING_INVENTORY and Player are not used in the code. Removing them helps maintain code cleanliness.

Apply this diff to remove the unused imports:

 from src.config.settings import GAME_BALANCE, STARTING_INVENTORY
+from src.config.settings import GAME_BALANCE

 from src.models.character import Player, get_fallback_enemy
+from src.models.character import get_fallback_enemy

🧰 Tools

🪛 Ruff (0.8.2)

17-17: src.config.settings.STARTING_INVENTORY imported but unused

Remove unused import: src.config.settings.STARTING_INVENTORY

(F401)

---

18-18: src.models.character.Player imported but unused

Remove unused import: src.models.character.Player

(F401)

---

98-99: Remove unused variable e in exception handling

The variable e is assigned but not used in the except block. This may cause a warning and can be safely removed.

Apply this diff to remove the unused variable:

 except Exception as e:
+except Exception:
     MessageView.show_error(

🧰 Tools

🪛 Ruff (0.8.2)

98-98: Local variable e is assigned to but never used

Remove assignment to unused variable e

(F841)

src/display/inventory/inventory_view.py (1)

13-13: Remove unused import Item from src.models.items.base

The Item class is imported but not used. Cleaning up unused imports improves code quality.

Apply this diff to remove the unused import:

- from src.models.items.base import Item

🧰 Tools

🪛 Ruff (0.8.2)

13-13: src.models.items.base.Item imported but unused

Remove unused import: src.models.items.base.Item

(F401)

docker-compose.yml (1)

11-12: Consider using non-default port mapping

Using the default PostgreSQL port (5432) might conflict with existing installations. Consider using a different host port.

     ports:
-      - "5432:5432"
+      - "5433:5432"

src/models/inventory.py (2)

4-6: Enhance function documentation and add type hints

The function documentation could be more descriptive and include type hints for better maintainability.

-def get_starting_items():
-    """Return the starting items for a new character"""
+from typing import List
+from .items.common_consumables import ConsumableItem
+
+def get_starting_items() -> List[ConsumableItem]:
+    """
+    Return the initial set of items for a new character.
+    
+    Returns:
+        List[ConsumableItem]: A list containing 3 health potions and 3 mana potions
+    """

---

8-10: Extract magic numbers to constants

Consider defining the potion quantities as constants for better maintainability.

+    STARTING_POTION_COUNT = 3
+
     # Add 3 of each basic potion
-    starting_items.extend([HEALTH_POTION for _ in range(3)])
-    starting_items.extend([MANA_POTION for _ in range(3)])
+    starting_items.extend([HEALTH_POTION for _ in range(STARTING_POTION_COUNT)])
+    starting_items.extend([MANA_POTION for _ in range(STARTING_POTION_COUNT)])

.github/dependabot.yml (2)

6-8: Consider monthly updates instead of weekly

For a game project, weekly dependency updates might be too frequent and could introduce unnecessary overhead. Monthly updates might be more appropriate unless there are security concerns.

     schedule:
-      interval: "weekly"
+      interval: "monthly"

---

1-29: Add version update configuration

Consider adding version update configuration to control the types of updates Dependabot creates.

     commit-message:
       prefix: "pip"
       include: "scope"
+    versioning-strategy:
+      increase: "patch"
+    allow:
+      - dependency-type: "direct"
+      - dependency-type: "indirect"

The configuration looks good overall, with appropriate labels and commit message formatting.

src/display/common/message_view.py (2)

8-12: Add return type hints to static methods

For better type safety and documentation, consider adding return type hints to the static methods.

-    def show_error(message: str):
+    def show_error(message: str) -> None:

-    def show_success(message: str):
+    def show_success(message: str) -> None:

-    def show_info(message: str):
+    def show_info(message: str) -> None:

Also applies to: 14-18, 20-23

---

4-23: Consider message buffering for multiplayer scenarios

Since this PR implements multiplayer support, consider enhancing the MessageView to handle concurrent message display from multiple players. This could involve:

1. Message queuing/buffering
2. Player-specific message filtering
3. Timestamp-based message ordering

Would you like me to propose a detailed implementation for multiplayer message handling?

src/display/ai/ai_view.py (2)

8-16: Add return type hints to static methods

For consistency with type safety practices, add return type hints to the static methods.

-    def show_generation_start(entity_type: str):
+    def show_generation_start(entity_type: str) -> None:

-    def show_generation_result(content: str):
+    def show_generation_result(content: str) -> None:

-    def show_error(error_msg: str):
+    def show_error(error_msg: str) -> None:

Also applies to: 17-22, 23-27

---

5-27: Consider AI generation coordination in multiplayer context

Since this PR implements multiplayer support, the AI generation display should handle scenarios where multiple players might trigger AI generation simultaneously. Consider:

1. Adding player context to messages
2. Implementing generation queue visualization
3. Adding progress indicators for long-running generations

Would you like me to propose a detailed implementation for handling concurrent AI generation displays?

src/models/items/equipment.py (1)

23-30: Move durability mapping to configuration

Consider moving the durability mapping to a configuration file for easier maintenance and potential runtime modification.

+# src/config/equipment_config.py
+DURABILITY_CONFIG = {
+    ItemRarity.COMMON: 40,
+    ItemRarity.UNCOMMON: 50,
+    ItemRarity.RARE: 60,
+    ItemRarity.EPIC: 80,
+    ItemRarity.LEGENDARY: 100,
+}

# In Equipment class
-        self.max_durability = {
-            ItemRarity.COMMON: 40,
-            ItemRarity.UNCOMMON: 50,
-            ItemRarity.RARE: 60,
-            ItemRarity.EPIC: 80,
-            ItemRarity.LEGENDARY: 100,
-        }[self.rarity]
+        self.max_durability = DURABILITY_CONFIG[self.rarity]

src/models/items/base.py (2)

1-1: Remove unused import

The Enum import is not used in this file.

-from enum import Enum

🧰 Tools

🪛 Ruff (0.8.2)

1-1: enum.Enum imported but unused

Remove unused import: enum.Enum

(F401)

---

6-20: Add input validation and docstring

The class would benefit from input validation and documentation.

 class Item:
+    """Base class for all game items.
+    
+    Attributes:
+        name (str): The name of the item
+        description (str): A description of the item
+        item_type (ItemType): The type of the item
+        rarity (ItemRarity): The rarity level of the item
+        value (int): The monetary value of the item
+        id (str): Unique identifier for the item
+    """
     def __init__(
         self,
         name: str,
         description: str,
         item_type: ItemType,
         rarity: ItemRarity,
         value: int,
     ):
+        if not name or not description:
+            raise ValueError("Name and description cannot be empty")
+        if value < 0:
+            raise ValueError("Value cannot be negative")
         self.name = name
         self.description = description
         self.item_type = item_type
         self.rarity = rarity
         self.value = value
         self.id = str(uuid4())

src/models/items/consumable.py (1)

16-16: Add type hints for use_effect return value

The use_effect callback should have a more specific return type hint.

-        use_effect: Optional[Callable[["Character"], bool]] = None,
+        use_effect: Optional[Callable[["Character"], bool | None]] = None,

src/config/logging_config.py (1)

11-12: Implement log rotation for production deployment

For AWS deployment, implement log rotation to manage disk space and log file lifecycle.

Consider using Python's RotatingFileHandler or TimedRotatingFileHandler to manage log files in production.

client/client.py (1)

6-41: Add connection timeout and reconnection logic

The WebSocket connection lacks timeout handling and reconnection logic, which are essential for multiplayer games.

Consider implementing a connection manager class with retry logic and timeout handling. Here's a basic example:

class GameConnectionManager:
    def __init__(self, uri: str, timeout: float = 30.0, max_retries: int = 3):
        self.uri = uri
        self.timeout = timeout
        self.max_retries = max_retries
        
    async def connect_with_retry(self):
        for attempt in range(self.max_retries):
            try:
                async with websockets.connect(
                    self.uri, 
                    timeout=self.timeout
                ) as websocket:
                    return await self.handle_connection(websocket)
            except Exception as e:
                if attempt == self.max_retries - 1:
                    raise
                await asyncio.sleep(2 ** attempt)  # Exponential backoff

src/display/base/base_view.py (2)

12-13: Add type hints and improve DEBUG_MODE initialization

Add proper type hints and consider using a more robust debug mode initialization.

-    DEBUG_MODE = os.getenv("DEBUG_MODE", False)
-    logger = logging.getLogger("display")
+    DEBUG_MODE: ClassVar[bool] = bool(os.getenv("DEBUG_MODE", "").lower() == "true")
+    logger: ClassVar[logging.Logger] = logging.getLogger("display")

---

38-47: Synchronize meditation effects in multiplayer mode

The meditation effects need to be synchronized across all players in multiplayer mode.

Consider implementing a game state synchronization mechanism:

1. Send meditation action to server
2. Server validates and broadcasts the effect to all players
3. Each client's view updates accordingly

Example implementation:

@staticmethod
async def display_meditation_effects(healing: int, player_id: str):
    """Display meditation/rest effects with multiplayer sync"""
    await game_state.broadcast_action({
        "type": "meditation",
        "player_id": player_id,
        "healing": healing
    })
    BaseView.clear_screen()
    # ... rest of the implementation

src/models/effects/base.py (2)

1-1: Remove unused import

The Enum import is not used in this file.

-from enum import Enum

🧰 Tools

🪛 Ruff (0.8.2)

1-1: enum.Enum imported but unused

Remove unused import: enum.Enum

(F401)

---

21-28: Add validation for chance parameter

The apply method should validate that the chance parameter is between 0 and 1.

def apply(
    self, target: GameEntity, source: Optional[GameEntity] = None
) -> Dict[str, Any]:
+   if not 0 <= self.chance <= 1:
+       raise ValueError("Chance must be between 0 and 1")
    if random.random() <= self.chance:
        return {"success": True, "message": f"{self.name} applied"}
    else:
        return {"success": False, "message": f"{self.name} failed to apply"}

src/display/boss/boss_view.py (2)

1-1: Remove unused import

The Optional type hint is not used in this file.

-from typing import Optional

🧰 Tools

🪛 Ruff (0.8.2)

1-1: typing.Optional imported but unused

Remove unused import: typing.Optional

(F401)

---

22-35: Consider performance impact of screen clearing

Frequent screen clearing with small delays might cause flickering on some terminals.

Consider using a single buffer for the corruption effect and updating it in-place instead of clearing the screen multiple times. This would provide a smoother visual experience.

src/display/themes/dark_theme.py (2)

15-16: Avoid symbol duplication

The "⚔" symbol is used for both "EQUIPMENT" and "STATS". Consider using distinct symbols for better clarity.

    "EQUIPMENT": "⚔",  # Equipment
    "CURSOR": "➤",  # Selection arrow
    # ... other symbols ...
-   "STATS": "⚔",
+   "STATS": "📊",  # Statistics

Also applies to: 26-27

---

64-65: Consider making widths configurable

Hard-coded width values might not work well with different terminal sizes or multiplayer views.

Consider making these values configurable based on terminal size or user preferences. This would be especially important for multiplayer support where screen real estate might be more constrained.

src/models/items/common_consumables.py (2)

1-8: Consider singleton pattern for ItemService

The ItemService instance is created at module level. In a multiplayer context, this could lead to potential race conditions if the service maintains any state.

Consider implementing ItemService as a singleton or dependency-injecting it from a central service manager.

---

67-70: Add docstring parameters and return type

The docstring for get_basic_consumables should include parameter and return type information.

 def get_basic_consumables() -> List[Consumable]:
-    """Return list of basic consumables available in shop"""
+    """
+    Return list of basic consumables available in shop.
+    
+    Returns:
+        List[Consumable]: List of common consumable items that can be purchased
+    """
     return COMMON_CONSUMABLES

src/display/effect/effect_view.py (1)

46-54: Consider using Enum for effect types

The effect type mapping uses string literals which could lead to maintenance issues.

Consider using an Enum for effect types:

from enum import Enum

class EffectType(Enum):
    STATUS = "STATUS"
    SET_BONUS = "SET_BONUS"
    ITEM_TRIGGER = "ITEM_TRIGGER"
    STAT_MODIFIER = "STAT_MODIFIER"

src/models/effects/set_effects.py (1)

66-75: Consider adding validation for effect parameters

The VoidwalkerSetEffect initializes with hardcoded values. Consider adding validation:

 @dataclass
 class VoidwalkerSetEffect(SetEffect):
     def __init__(self):
+        if not (0 < VoidShieldEffect(0.25).shield_percentage <= 1):
+            raise ValueError("Shield percentage must be between 0 and 1")
         super().__init__(
             name="Voidwalker's Embrace",
             description="Harness the power of the void",
             stat_bonuses={"max_health": 30, "defense": 15},
             required_pieces=3,
             effects=[VoidShieldEffect(0.25)],
         )

src/display/character/character_view.py (1)

66-77: Optimize decorative elements and fix f-string

A few improvements for the skills display section:

-                    print(f"\n  ✤ Skills:")
+                    print("\n  ✤ Skills:")
+                    # Cache random choices to avoid repeated calls
+                    skill_runes = [random.choice(dec["RUNES"]) for _ in range(len(char_class.skills))]
                     for skill in char_class.skills:
-                        rune = random.choice(dec["RUNES"])
+                        rune = next(skill_runes)

🧰 Tools

🪛 Ruff (0.8.2)

67-67: f-string without any placeholders

Remove extraneous f prefix

(F541)

src/models/items/rare_items.py (1)

11-44: Consider adding documentation for effect values and validation for stat modifiers.

While the implementation is solid, consider:

1. Documenting the reasoning behind proc chances and effect values
2. Adding validation to ensure stat modifiers are within balanced ranges

Example validation implementation:

def validate_stat_modifiers(modifiers: dict, item_type: ItemType) -> None:
    """Validate stat modifiers are within acceptable ranges."""
    ranges = {
        ItemType.WEAPON: {"attack": (10, 20), "magic_power": (-10, 20)},
        ItemType.ARMOR: {"defense": (5, 15), "max_health": (20, 50)},
        ItemType.ACCESSORY: {"attack": (5, 15), "magic_power": (5, 15)}
    }
    
    for stat, value in modifiers.items():
        if stat in ranges[item_type]:
            min_val, max_val = ranges[item_type][stat]
            if not min_val <= value <= max_val:
                raise ValueError(f"Invalid {stat} modifier: {value}")

Also applies to: 46-71, 73-106, 108-128

src/models/items/common_items.py (2)

49-76: Consider balancing weapon stats

The weapons collection shows some potential balance issues:

• Iron Sword (attack: 5) vs Iron Mace (attack: 6) - same weapon tier but different stats
• Throwing Knives (attack: 2, speed: 3) vs Steel Dagger (attack: 3, speed: 2) - throwing weapons shouldn't be weaker

Consider rebalancing the weapons to maintain consistent power levels within the same tier.

---

226-228: Consider categorizing items by rarity

The COMMON_ITEMS list combines all items without maintaining category information. This might make it harder to filter items by type when needed.

Consider using a dictionary structure:

-COMMON_ITEMS = COMMON_WEAPONS + COMMON_ARMOR + COMMON_ACCESSORIES
+COMMON_ITEMS = {
+    "weapons": COMMON_WEAPONS,
+    "armor": COMMON_ARMOR,
+    "accessories": COMMON_ACCESSORIES
+}

src/models/character.py (1)

408-520: Improve fallback enemy generation

The fallback enemy system has several potential improvements:

1. The player_level parameter is unused
2. Enemy stats don't scale with player level
3. Art strings could be moved to a separate configuration file

Consider implementing level scaling:

def get_fallback_enemy(player_level: int = 1) -> Enemy:
    enemy_data = random.choice(fallback_enemies)
    level_multiplier = max(1, player_level / enemy_data["level"])
    
    return Enemy(
        name=enemy_data["name"],
        description=enemy_data["description"],
        health=int(enemy_data["base_health"] * level_multiplier),
        attack=int(enemy_data["base_attack"] * level_multiplier),
        defense=int(enemy_data["base_defense"] * level_multiplier),
        level=player_level,
        art=enemy_data["art"],
        exp_reward=int(enemy_data["exp_reward"] * level_multiplier),
    )

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

    - uses: hashicorp/setup-terraform@v3
      with:
        terraform_version: "1.0.0"

    - uses: aws-actions/configure-aws-credentials@v4
      with:
        role-to-assume: ${{ secrets.AWS_ROLE_ARN }}
        aws-region: eu-west-1

    - name: Terraform Init
      run: |
        cd terraform/server
        terraform init -backend=false

    - name: Terraform Validate
      run: |
        cd terraform/server
        terraform validate

#!/bin/bash
# Look for AWS-related configuration files
echo "Searching for AWS configuration files..."
fd -e yaml -e yml -e json -e tf . | grep -i "aws\|terraform\|cloudformation"

# Look for AWS SDK usage in Python files
echo "Checking for AWS SDK usage..."
rg "boto3|aws" -t py

#!/bin/bash
# Check terraform configuration files
echo "Content of main.tf:"
cat terraform/server/main.tf

echo -e "\nContent of providers.tf:"
cat terraform/server/providers.tf

echo -e "\nContent of versions.tf:"
cat terraform/server/versions.tf

 print(f"\n{dec['SECTION']['START']}Players{dec['SECTION']['END']}")
 for player in players:
+    # Player name and turn indicator
+    turn_indicator = "► " if player.is_current_turn else "  "
+    print(f"\n  {turn_indicator}{player.name}")
+
     # Player health bar
     player_health_percent = player.health / player.max_health

     def __eq__(self, other):
         if not isinstance(other, Item):
             return NotImplemented
         return (
             self.name == other.name
             and self.description == other.description
             and self.item_type == other.item_type
             and self.rarity == other.rarity
+            and self.value == other.value
         )

     def __hash__(self):
-        return hash((self.name, self.description, self.item_type, self.rarity))
+        return hash((self.name, self.description, self.item_type, self.rarity, self.value))

#!/bin/bash
# Check other consumables' stats for comparison
rg -A 10 "create_consumable|healing.*=|mana_restore.*=|damage.*=" --type py

     ItemService.create_consumable(
         name="Void Walker's Essence",
         description="Essence that allows temporary mastery over the void",
         value=250,
         rarity=ItemRarity.EPIC,
+        # Effects stack multiplicatively with other buffs
         effects=[
             VoidShieldEffect(0.35),
             StatModifierEffect("magic_power", 25, duration=3),
             StatModifierEffect("max_mana", 50, duration=3),
         ],
     ),

#!/bin/bash
# Check for effect stacking implementation
ast-grep --pattern 'class $effect extends BaseEffect {
  $$$
  apply($char) {
    $$$
  }
}'

#!/bin/bash
# Let's try a different approach to find effect-related classes and their implementations
rg -l "class.*Effect" --type py

# Then let's look for any documentation about effect stacking
rg -i "stack|combine|multiple" --type py -C 2

#!/bin/bash
# Let's examine the base effect implementation and stat modifier effect
cat src/models/effects/base.py
cat src/models/effects/item_effects.py

FALLBACK_SYMBOLS = {
    "HEALTH": "H",
    "MANA": "*",
    # ... other ASCII alternatives
}

#!/bin/bash
# Search for balance configuration or similar potions
rg -A 2 "healing.*=.*30|mana_restore.*=.*35" --type py

#!/bin/bash
# Search for item balance configurations and similar consumables
rg -l "create_consumable|healing.*=|mana_restore.*=" --type py | xargs cat

# Also look for any balance testing or configuration files
fd -e py "balance|config" --exec cat {}

#!/bin/bash
# Search for game balance settings and configurations
rg -A 5 "GAME_BALANCE|healing.*=|mana_restore.*=" --type py

# Also look for other consumables to compare ratios
fd -e py "consumables" --exec cat {}

#!/bin/bash
# Description: Verify shop implementation matches configuration
# Look for shop type implementations
ast-grep --pattern 'class $SHOP_TYPE extends Shop {
  $$$
}'

# Look for shop type handling
rg -A 5 'SHOP_TYPE_WEIGHTS|SHOP_TYPE_BONUSES|BASE_POTION_STOCK'

#!/bin/bash
# Look for ShopType enum definition
ast-grep --pattern 'class ShopType$_:
  $$$'

# Look for Shop base class and its methods
ast-grep --pattern 'class Shop$_:
  $$$'

# Look for specific shop type handling in methods
rg -A 3 'def.*shop_type'

#!/bin/bash
# Look for enum definition with specific values
rg -A 5 "class ShopType"

# Look for Shop class and its implementation
rg -A 10 "class Shop"

# Look for specific shop type implementations
rg -A 5 "GENERAL|BLACKSMITH|ALCHEMIST|MYSTIC.*=|shop_type.*="